package main

import (
	"fmt"
	"runtime"
	"time"

	modbus "gitee.com/barryzxy/gomodbus"
)

// 高性能功能演示
// 展示新增的优化功能如何提升性能并保持API兼容性

func main() {
	fmt.Println("=== Modbus 库新增优化功能演示 ===")
	fmt.Println("展示内存池、高性能API、连接池等优化功能")

	// 1. 基础向后兼容演示
	demonstrateBackwardCompatibility()

	// 2. 高性能API演示
	demonstrateHighPerformanceAPI()

	// 3. 连接池功能演示
	demonstrateConnectionPool()

	// 4. 批量操作演示
	demonstrateBatchOperations()

	// 5. 内存优化效果展示
	demonstrateMemoryOptimization()

	fmt.Println("\n🎉 所有优化功能演示完成！")
}

// demonstrateBackwardCompatibility 演示向后兼容性
func demonstrateBackwardCompatibility() {
	fmt.Println("\n📊 1. 向后兼容性演示")
	fmt.Println("现有代码无需任何修改即可获得优化好处")

	// 创建标准客户端（现在内部使用了优化的错误处理）
	provider := modbus.NewTCPClientProvider("localhost:502",
		modbus.WithEnableLogger())
	client := modbus.NewClient(provider)

	fmt.Println("✅ 标准客户端创建成功")
	fmt.Println("  - 自动使用优化的错误处理")
	fmt.Println("  - 自动使用内存池优化")
	fmt.Println("  - API 100% 兼容")

	// 模拟API调用（无需服务器）
	fmt.Println("💡 原有API调用示例（无需修改代码）：")
	fmt.Println("  client.ReadHoldingRegisters(1, 0, 10)")
	fmt.Println("  client.WriteMultipleRegisters(1, 0, 5, values)")

	_ = client // 避免编译警告
}

// demonstrateHighPerformanceAPI 演示高性能API
func demonstrateHighPerformanceAPI() {
	fmt.Println("\n🚀 2. 高性能API演示")
	fmt.Println("新增高性能API，减少内存分配和GC压力")

	// 创建高性能客户端
	provider := modbus.NewTCPClientProvider("localhost:502")
	hpClient := modbus.NewHighPerformanceClient(provider)

	fmt.Println("✅ 高性能客户端创建成功")

	// 演示使用用户缓冲区的读取操作
	coilsBuf := make([]byte, 10)
	regsBuf := make([]uint16, 10)

	fmt.Println("📦 高性能API特性：")
	fmt.Printf("  - 用户提供缓冲区: len(coilsBuf)=%d, len(regsBuf)=%d\n",
		len(coilsBuf), len(regsBuf))
	fmt.Println("  - 减少内存分配")
	fmt.Println("  - 零拷贝优化")
	fmt.Println("  - 完全向下兼容标准Client接口")

	// 模拟高性能API调用
	fmt.Println("💡 高性能API调用示例：")
	fmt.Println("  n, err := hpClient.ReadCoilsWithBuf(1, 0, 8, coilsBuf)")
	fmt.Println("  n, err := hpClient.ReadHoldingRegistersWithBuf(1, 0, 5, regsBuf)")
	fmt.Println("  err := hpClient.WriteMultipleRegistersOptimized(1, 0, values)")

	_ = hpClient
}

// demonstrateConnectionPool 演示连接池功能
func demonstrateConnectionPool() {
	fmt.Println("\n🔗 3. 连接池功能演示")
	fmt.Println("新增连接池支持，提高连接复用率")

	// 创建连接池客户端
	pooledClient := modbus.NewPooledClient("localhost:502")

	fmt.Println("✅ 连接池客户端创建成功")
	fmt.Println("📊 连接池特性：")
	fmt.Println("  - 自动连接复用")
	fmt.Println("  - 最大空闲连接数: 10")
	fmt.Println("  - 最大打开连接数: 100")
	fmt.Println("  - 空闲超时: 5分钟")
	fmt.Println("  - 自动清理过期连接")

	// 创建高性能连接池客户端
	hpPooledClient := modbus.NewHighPerformancePooledClient("localhost:502")

	fmt.Println("🚀 高性能连接池客户端创建成功")
	fmt.Println("  - 结合高性能API和连接池")
	fmt.Println("  - 最佳性能表现")

	_ = pooledClient
	_ = hpPooledClient
}

// demonstrateBatchOperations 演示批量操作
func demonstrateBatchOperations() {
	fmt.Println("\n📦 4. 批量操作演示")
	fmt.Println("新增批量操作API，提高高吞吐量场景性能")

	provider := modbus.NewTCPClientProvider("localhost:502")
	hpClient := modbus.NewHighPerformanceClient(provider)

	// 创建批量操作实例
	batchOps := modbus.NewBatchOperations(hpClient)

	fmt.Println("✅ 批量操作实例创建成功")
	fmt.Println("📊 批量操作特性：")
	fmt.Println("  - 复用内部缓冲区")
	fmt.Println("  - 减少内存分配")
	fmt.Println("  - 适用于高吞吐量场景")

	// 准备批量操作参数
	addresses := []uint16{0, 10, 20, 30, 40}
	quantities := []uint16{5, 5, 5, 5, 5}

	fmt.Printf("💡 批量操作示例（%d个操作）：\n", len(addresses))
	fmt.Println("  // 批量读取多个线圈组")
	fmt.Println("  results, err := batchOps.ReadMultipleCoils(1, addresses, quantities)")
	fmt.Println("  // 批量读取多个寄存器组")
	fmt.Println("  results, err := batchOps.ReadMultipleHoldingRegisters(1, addresses, quantities)")

	_ = batchOps
	_ = addresses
	_ = quantities
}

// demonstrateMemoryOptimization 演示内存优化效果
func demonstrateMemoryOptimization() {
	fmt.Println("\n💾 5. 内存优化效果演示")
	fmt.Println("展示内存池和优化带来的性能提升")

	// 获取初始内存状态
	runtime.GC()
	var m1 runtime.MemStats
	runtime.ReadMemStats(&m1)

	fmt.Printf("📊 初始内存状态: %d KB\n", m1.Alloc/1024)

	// 模拟大量操作（使用优化的函数）
	fmt.Println("🔄 执行大量转换操作...")

	const iterations = 10000
	start := time.Now()

	for i := 0; i < iterations; i++ {
		// 使用优化的转换函数
		values := []uint16{1, 2, 3, 4, 5}

		// 测试内存池优化的uint162Bytes
		data := modbus.Uint162Bytes(values...)
		_ = data

		// 测试字节到uint16转换
		testBytes := []byte{0, 1, 0, 2, 0, 3, 0, 4, 0, 5}
		result := modbus.Bytes2Uint16(testBytes)
		_ = result
	}

	duration := time.Since(start)

	// 获取最终内存状态
	runtime.GC()
	var m2 runtime.MemStats
	runtime.ReadMemStats(&m2)

	fmt.Printf("⏱️  操作耗时: %v\n", duration)
	fmt.Printf("📊 最终内存状态: %d KB\n", m2.Alloc/1024)
	fmt.Printf("📈 内存变化: %+d KB\n", int64(m2.Alloc-m1.Alloc)/1024)
	fmt.Printf("🔄 GC次数增加: %d\n", m2.NumGC-m1.NumGC)
	fmt.Printf("🚀 平均每次操作: %.2f μs\n", float64(duration.Nanoseconds())/float64(iterations)/1000)

	fmt.Println("\n💡 优化效果总结：")
	fmt.Println("  ✅ 内存池减少频繁分配")
	fmt.Println("  ✅ 错误消息复用减少字符串分配")
	fmt.Println("  ✅ 缓冲区复用减少GC压力")
	fmt.Println("  ✅ 高性能API提供零拷贝选项")
	fmt.Println("  ✅ 连接池提高连接复用率")
}

// 需要导出的测试函数以支持示例中的调用
func init() {
	// 这些函数需要在modbus包中作为公共API导出
	// 在实际实现中，应该在相应的源文件中导出这些函数
}
